import java.util.HashMap;
import java.util.Map;

public class PP {

	class Ent {

	}

	public static void main(String... args) {

		/*
		 * for (int i = 0; i < 10; i++) { System.out.println(i + "!=" +
		 * factorial(i)); System.out.println(i + "!=" + factorial2(i)); }
		 */

		// hanoi(1,3, 3);
		// System.out.println(j);
		// System.out.println(summa2(5));
	}

	// //////////////////////////////////////////////////////////////////////////////////////

	
	// ////////////////////////////////////////////////////////////////

	

	public static int summa(int a) {
		int result = 0;
		for (int i = 0; i <= a; i++) {
			result += i;
		}
		return result;
	}

	public static int summa1(int a) {
		int result = 0;
		for (int i = 0; i <= a; i++) {
			if (isChetnoe(i)) {
				result += i;
			}
		}
		return result;
	}

	public static int summa2(int a) {
		int result = 0;
		boolean isAChetnoe = isChetnoe(a);
		for (int i = 0; i <= a; i++) {
			if (isAChetnoe) {
				if (isChetnoe(i)) {
					result += i;
				}
			} else if (!isChetnoe(i)) {
				result += i;
			}
		}
		return result;
	}

	public static boolean isChetnoe(int a) {
		return (a % 2 == 0);
	}

	// //////////////////////////////////////////////////////////////////////////////

	static int j = 0;

	public static void hanoi(int start, int end, int colvo) {
		j++;

		if (colvo == 1) {
			System.out.println("s " + start + " na " + end);
		} else if (colvo > 1) {
			hanoi(start, end, colvo - 1);
			hanoi(start, 2, 1);
			hanoi(end, start, colvo - 1);
			hanoi(2, end, 1);
			hanoi(start, end, colvo - 1);
		}
	}

	public static void a(int arg) {

		System.out.println(arg);
		arg++;
		if (arg < 10) {
			a(arg);
		}

	}

	static int factorial2(int arg) {

		if (arg < 0) {
			throw new IllegalArgumentException("nah - otritz argument!");
		}
		if (arg == 0) {
			arg = 1;
		} else if (arg > 1) {
			int j = arg;
			for (int i = 1; i < j; i++) {
				arg = arg * i;
			}
		}

		return arg;
	}

	static int factorial(int arg) {
		if (arg < 0) {
			throw new IllegalArgumentException("nah - otritz argument!");
		}
		if (arg == 0) {
			arg = 1;
		} else if (arg > 1) {
			arg = arg * factorial(arg - 1);
		}
		return arg;
	}

	
	// public static void main(String[] args) {
	//		
	//		
	// int[] massiv = new int []{5,4,3,2,1,0,6,7,8,9};
	//		 
	// for (int i = 0; i < massiv.length; i++) {
	// System.out.print(massiv[i] + " ");
	// }
	//		
	// System.out.println("");
	//						
	// int iterationCount = 0;
	// for (int i = 0; i < massiv.length; i++) {
	//			
	// for (int j = 0; j < massiv.length-i-1; j++){
	// iterationCount++;
	// if(massiv[j] > massiv[j+1]){
	//					
	// int temp0 = massiv[j];
	// int temp1 = massiv[j+1];
	// massiv[j] = temp1;
	// massiv[j+1] = temp0;
	// }
	// }
	// }
	//		
	// for (int i = 0; i < massiv.length; i++) {
	// System.out.print(massiv[i] +" ");
	// }
	//		
	// System.out.println();
	// System.out.println(iterationCount);
	//		
	// }
	// }

	// /////////////////////////////////////////////////////////////////////////////////////////

	// public static void main(String[] args){
	// int[] massiv = new int[]{5,4,3,2,1,0,6,7,8,9};
	//		
	// for (int i = 0; i < massiv.length; i++) {
	// System.out.print(massiv[i] + " ");
	// }
	// System.out.println("");
	//		
	// iskatChislo(massiv, 5);
	//		
	// }
	//	
	// public static int iskatChislo(int[] mas, int chiclo){
	//		
	// int index = 0;
	// int element = mas[index];
	//		
	// for (int i = 0; i < mas.length; i++){
	// if(mas[i]== chiclo){
	// element = mas[i];
	// index = i;
	// }
	// }
	//		
	// System.out.println(index);
	// return index;
	// }
	// ///////////////////////////////////////////////////////////////////////////////////////

	public static void mainOld(String[] args) {

		/*
		 * int [] arr = new int[] {10,8,7,6}; for (int i = 0; i < arr.length;
		 * i++) { System.out.print(arr[i] + ","); } arr = sort(arr);
		 * System.out.println(); for (int i = 0; i < arr.length; i++) {
		 * System.out.print(arr[i] + ","); }
		 */

		Map map = new HashMap();
		map.put(1, 1);
		map.put(1, 2);
		System.out.println(map);

	}

	
	private static int[] sort(int[] array) {

		for (int j = 0; j < array.length - 1; j++) {
			int startIndex = j;
			int min = array[startIndex];
			int minIndex = startIndex;
			for (int i = startIndex; i < array.length; i++) {
				int tmp = array[i];
				if (tmp < min) {
					min = tmp;
					minIndex = i;
				}
			}
			int tmp0 = array[startIndex];
			int tmp1 = array[minIndex];
			array[minIndex] = tmp0;
			array[startIndex] = tmp1;
		}
		return array;
	}

	public static void main01(String[] args) {

		int[] sortedArray = new int[] { 3, 5, 13, 35, 56, 112, 120, 136 };

		for (int i = 0; i < sortedArray.length; i++) {
			System.out.print(sortedArray[i] + " ");

		}

		System.out.println();

		for (int i = 0; i < sortedArray.length; i++) {
			int result = findValueIndex(sortedArray, sortedArray[i]);
			System.out.println(result);
		}

		int result = findValueIndex(sortedArray, 100);
		System.out.println(result);

	}// main

	public static void main0(String[] arg) {

		// testDefineMiddele();
	}

	public static int findValueIndex(int[] sortedArray, int value) {

		int start = 0;
		int end = sortedArray.length - 1;
		int index = -1;

		boolean ravno = true;
		while (ravno) {

			int seredina = defineMiddle(start, end);
			int currentValue = sortedArray[seredina];

			if (currentValue == value) {

				index = seredina;
				ravno = false;

			} else if (start == end) {

				ravno = false;

			} else if (currentValue < value) {

				// end = end;
				start = seredina;

			} else if (currentValue > value) {

				end = seredina - 1;
				// start = start;
			}

		}

		return index;
	}

	
	public static int defineMiddle(int start, int end) {

		if (start < 0) {
			throw new RuntimeException("Start parameter must be positive!");
		}
		if (end < 0) {
			throw new RuntimeException("End parameter must be positive!");
		}

		int ser = (int) Math.floor((end - start) + 1) / 2 + start;
		return ser;
	}

	// int iskomoe = 13;
	//		
	// int index = 0;
	// int element = massiv[index];
	//		
	// int endInd = massiv.length-1;
	// int startInd = massiv[0];
	//		
	//		
	// int ser = (int)Math.floor((endInd-startInd)+1)/2+ startInd;
	//		
	// while(iskomoe != ser ){
	// if (iskomoe == ser){
	// element = massiv[ser];
	// index = ser;
	//				
	//				
	// }else
	//			
	//			
	// if( iskomoe > ser ){
	// endInd = massiv.length-1;
	// startInd = ser;
	//		
	// }else
	//			
	// if(iskomoe < ser){
	// endInd = ser;
	// startInd = massiv[0];
	//				
	//				
	// }
	//				
	// }
	//		
	// System.out.println(ser);
	//		
	// }
	//	

}
